This PR extends higher-order patterns inside quote patterns to allow type parameters. When this PR is merged, we'll be able to write quote patterns like the following example with an experimental flag experimental.quotedPatternsWithPolymorphicFunctions.

def decomposePoly(x: Expr[Any])(using Quotes): Expr[Int] =
  x match
    case '{ [A] => (x: List[A]) => $y[A](x) : Int } =>
      '{ $y[Int](List(1, 2, 3)) }
    case _ => Expr(0)

You can see that the higher-order pattern $y[A](x) carries an type parameter A. It states that this pattern matches a code fragment with occurrences of A, and y is assigned a polymorphic function type [A] => List[A] => x.

This PR mainly changes two parts: type checker and quote pattern matcher. Those changes are based on the formalized type system defined in Nicolas Stucki's thesis, and one can expect the soundness of the implementation.

Type Dependency

If a higher-order pattern carries a value parameter with a type that has type parameters defined in the quoted pattern, those type parameters should also be captured in the higher-order pattern. For example, the following pattern will not be typed.

case '{ [A] => (x: List[A]) => $y(x) : Int } =>

In this case, x has the type List[A], which includes a type variable A that is defined in the pattern. However, the higher-order pattern $y(x) does not have any type parameters. This should be ill-typed. One can always avoid this kind of type errors by adding type parameters, like $y[A](x)

Implementation Restriction

Current implementation only allows type parameters that do not have bounds, because sound typing rules for such pattern is not clear yet.

case '{ [A] => (x: List[A]) => $y(x) : Int } => // Allowed
case '{ [A <: Int] => (x: List[A]) => $y(x) : Int } => // Disallowed